PART - ONE¶
Face detection from training images¶
Importing the necessary libraries¶
In [1]:
import cv2
import numpy as np
import os
import matplotlib.pyplot as plt
In [3]:
import numpy as np
# save np.load
np_load_old = np.load
# modify the default parameters of np.load
np.load = lambda *a,**k: np_load_old(*a, allow_pickle=True, **k)
data = np.load('images.npy')
Checking out a couple of samples from the loaded data¶
In [4]:
data[13][1]
Out[4]:
The sample with index 13 has got 4 faces.¶
In [8]:
data[13][0]
Out[8]:
In [6]:
data[3][1]
Out[6]:
The sample with index 3 has got 1 face.¶
In [7]:
data[3][0]
Out[7]:
Setting the values of image width,height and alpha¶
In [10]:
height = 224
width = 224
alpha = 1
Creating the features (images) and labels (masks) using the data¶
In [11]:
import cv2
from tensorflow.keras.applications.mobilenet import preprocess_input
masks = np.zeros((int(data.shape[0]), height, width))
X_train = np.zeros((int(data.shape[0]), height, width, 3))
for index in range(data.shape[0]):
img = data[index][0]
img = cv2.resize(img, dsize=(height, width), interpolation=cv2.INTER_CUBIC)
try:
img = img[:, :, :3]
except:
continue
X_train[index] = preprocess_input(np.array(img, dtype=np.float32))
for i in data[index][1]:
x1 = int(i["points"][0]['x'] * width)
x2 = int(i["points"][1]['x'] * width)
y1 = int(i["points"][0]['y'] * height)
y2 = int(i["points"][1]['y'] * height)
masks[index][y1:y2, x1:x2] = 1
In [12]:
# Printing out the shapes of X_train and mask
print('The shape of X_train is: ',X_train.shape)
print('The shape of mask is: ',masks.shape)
Out[12]:
In [14]:
# Displaying the image with index 13
n = 13
print(X_train[n])
plt.imshow(X_train[n])
Out[14]:
In [17]:
# Displaying the image with index 15
n = 15
print(X_train[n])
plt.imshow(X_train[n])
Out[17]:
In [19]:
# Displaying the mask of the image with index 15. Clarly we can see that 3 masks are there for 3 faces
plt.imshow(masks[n])
Out[19]:
In [51]:
from tensorflow.keras.applications.mobilenet import MobileNet
from tensorflow.keras.layers import Concatenate, UpSampling2D, Conv2D, Reshape
from tensorflow.keras.models import Model
import tensorflow as tf
cell_height = 28
cell_width = 28
batch_size = 1
threads = 1
Creating the model using MobileNet¶
In [52]:
model = MobileNet(input_shape=(height, width, 3), include_top=False, alpha=alpha, weights="imagenet")
model.summary()
Adding the layers of U-NET architecture¶
In [61]:
def create_model(trainable=True):
model = MobileNet(input_shape=(height, width, 3), include_top=False, alpha=aplha, weights="imagenet")
for layer in model.layers:
layer.trainable = trainable
block0 = model.get_layer("conv_pw_1_relu").output
block = model.get_layer("conv_pw_1_relu").output
block1 = model.get_layer("conv_pw_3_relu").output
block2 = model.get_layer("conv_pw_5_relu").output
block3 = model.get_layer("conv_pw_11_relu").output
block4 = model.get_layer("conv_pw_13_relu").output
x = Concatenate()([UpSampling2D()(block4), block3])
x = Concatenate()([UpSampling2D()(x), block2])
x = Concatenate()([UpSampling2D()(x), block1])
x = Concatenate()([UpSampling2D()(x), block])
# x = Concatenate()([UpSampling2D()(x), block0])
x = UpSampling2D()(x)
x = Conv2D(1, kernel_size=1, activation="sigmoid")(x)
x = Reshape((height, height))(x)
return Model(inputs=model.input, outputs=x)
In [62]:
model = create_model()
# Print summary
model.summary()
Designing the dice coefficient and the loss function¶
In [63]:
from tensorflow.keras.losses import binary_crossentropy
from tensorflow.keras.backend import log, epsilon
def dice_coefficient(y_true, y_pred):
numerator = 2 * tf.reduce_sum(y_true * y_pred)
denominator = tf.reduce_sum(y_true + y_pred)
return numerator / (denominator + tf.keras.backend.epsilon())
def loss(y_true, y_pred):
return binary_crossentropy(y_true, y_pred) - log(dice_coefficient(y_true, y_pred) + epsilon())
Compiling the model¶
In [65]:
model = create_model(False)
model.summary()
model.compile(loss=loss, optimizer='Adam', metrics=[dice_coefficient])
Making predictions¶
In [66]:
model.fit(X_train,masks,epochs = 10,verbose=1,batch_size=1)
Out[66]:
---------------------------------------------------------------------------------------------------------¶
PART - TWO¶
Curation of the bounding box co-ordinates for each image (automated)¶
In [32]:
import numpy as np
import cv2
import glob
# Using the Haar Cascade classifier
face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
In [51]:
# Storing the paths of all images present in the directory, in a list
images_list = glob.glob('C:/Users/admin/Desktop/Great Learning/Advanced Computer Vision/training_images/*')
In [53]:
# Finding out the number of images present in the directory
print('The number of images found is: ',len('C:/Users/admin/Desktop/Great Learning/Advanced Computer Vision/training_images\\'))
Out[53]:
In [54]:
# Storing only the image names in the images_list list
for i in range(len(images_list)):
images_list[i] = images_list[i][79:]
# print(i)
images_list
Out[54]:
In [55]:
import pandas as pd
df = pd.DataFrame(data=[],columns=['x','y','w','h','Total_Faces','Image_Name'])
for image in images_list:
name = image
img = cv2.imread('C:/Users/admin/Desktop/Great Learning/Advanced Computer Vision/training_images/' + image)
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
faces = face_cascade.detectMultiScale(gray, 1.1, 5)
# print('number of faces:')
# print(len(faces))
for (x,y,w,h) in faces:
l = []
l.append(x)
l.append(y)
l.append(w)
l.append(h)
l.append(len(faces))
l.append(name)
cv2.rectangle(img,(x,y),(x+w,y+h),(255,0,0),2)
roi_gray = gray[y:y+h, x:x+w]
roi_color = img[y:y+h, x:x+w]
df2 = pd.DataFrame(data=[l],columns=['x','y','w','h','Total_Faces','Image_Name'])
df = df.append(df2)
# cv2.imshow('img',img)
# cv2.waitKey(0)
In [56]:
df.head()
Out[56]:
---------------------------------------------------------------------------------------------------------¶
PART - THREE¶
Using a pre-trained model trained on Face recognition to recognise similar faces¶
In [1]:
# Imports
import pandas as pd, numpy as np, matplotlib.pyplot as plt, sklearn, re, random
import matplotlib.gridspec as gridspec
from tqdm.notebook import tqdm
import tensorflow, cv2
%matplotlib inline
# Extract content from zipfile
from zipfile import ZipFile
# Model
from tensorflow.keras.layers import ZeroPadding2D, Convolution2D, MaxPooling2D, Dropout, Flatten, Activation
from tensorflow.keras.models import Sequential, Model
from sklearn.svm import SVC
# Encode, standardize and PCA
from sklearn.metrics import classification_report, confusion_matrix, accuracy_score
from sklearn.model_selection import RandomizedSearchCV, GridSearchCV
from sklearn.preprocessing import LabelEncoder, StandardScaler
from sklearn.decomposition import PCA
In [2]:
import glob
pins = glob.glob('C:/Users/admin/Desktop/Great Learning/Advanced Computer Vision/PINS/PINS/*')
pins
Out[2]:
In [3]:
for i in range(len(pins)):
pins[i] = pins[i][73:]
pins
Out[3]:
In [4]:
print('The number of celebrities present is: ',len(pins))
In [5]:
# Selecting a random folder and then a random image from the lot
import random
path = 'C:/Users/admin/Desktop/Great Learning/Advanced Computer Vision/PINS/PINS/'
selection1 = random.choice(pins)
img_path = path +'/'+ selection1 +'/'+ '*'
selection_list = glob.glob(img_path)
selection2 = random.choice(selection_list)
print(selection2)
In [6]:
# Displaying the image
image = cv2.imread(selection2)
plt.axis("off")
plt.title(selection1[5:])
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.show()
Building the face model using VGG¶
In [7]:
def vgg_face():
model = Sequential()
model.add(ZeroPadding2D((1, 1), input_shape = (224, 224, 3)))
model.add(Convolution2D(64, (3, 3), activation = 'relu'))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(64, (3, 3), activation = 'relu'))
model.add(MaxPooling2D((2, 2), strides = (2, 2)))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(128, (3, 3), activation = 'relu'))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(128, (3, 3), activation = 'relu'))
model.add(MaxPooling2D((2, 2), strides = (2, 2)))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(256, (3, 3), activation = 'relu'))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(256, (3, 3), activation = 'relu'))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(256, (3, 3), activation = 'relu'))
model.add(MaxPooling2D((2, 2), strides = (2, 2)))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(512, (3, 3), activation = 'relu'))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(512, (3, 3), activation = 'relu'))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(512, (3, 3), activation = 'relu'))
model.add(MaxPooling2D((2, 2), strides =(2, 2)))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(512, (3, 3), activation = 'relu'))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(512, (3, 3), activation = 'relu'))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(512, (3, 3), activation = 'relu'))
model.add(MaxPooling2D((2, 2), strides=(2, 2)))
model.add(Convolution2D(4096, (7, 7), activation = 'relu'))
model.add(Dropout(0.5))
model.add(Convolution2D(4096, (1, 1), activation = 'relu'))
model.add(Dropout(0.5))
model.add(Convolution2D(2622, (1, 1)))
model.add(Flatten())
model.add(Activation('softmax'))
return model
In [8]:
# Model Summary
model = vgg_face()
model.load_weights('C:/Users/admin/Desktop/Great Learning/Advanced Computer Vision/Part 3 - vgg_face_weights.h5')
print(model.summary())
Functions have been defined for loading the meta data¶
In [10]:
import os
class IdentityMetadata():
def __init__(self, base, name, file):
# print(base, name, file)
# dataset base directory
self.base = base
# identity name
self.name = name
# image file name
self.file = file
def __repr__(self):
return self.image_path()
def image_path(self):
return os.path.join(self.base, self.name, self.file)
def load_metadata(path):
metadata = []
exts = []
for i in os.listdir(path):
for f in os.listdir(os.path.join(path, i)):
# Check file extension. Allow only jpg/jpeg' files.
ext = os.path.splitext(f)[1]
if ext == '.jpg' or ext == '.jpeg':
metadata.append(IdentityMetadata(path, i, f))
exts.append(ext)
return np.array(metadata), exts
metadata, exts = load_metadata(path)
labels = np.array([meta.name for meta in metadata])
Defining the VGG Face Descriptor¶
In [11]:
vgg_face_descriptor = Model(inputs = model.layers[0].input, outputs = model.layers[-2].output)
Embedding for the images¶
In [12]:
# Get embedding vector for first image in the metadata using the pre-trained model
image = cv2.imread(metadata[0].image_path())
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
# Normalising pixel values from [0-255] to [0-1]: scale RGB values to interval [0, 1]
img = (image / 255.).astype(np.float32)
img = cv2.resize(img, dsize = (224, 224))
print(img.shape)
# Obtain embedding vector for an image
# Get the embedding vector for the above image using vgg_face_descriptor model and print the shape
embedding_vector = vgg_face_descriptor.predict(np.expand_dims(img, axis = 0))[0]
print(embedding_vector.shape)
Get embeddings for all the images¶
Function to load the image¶
In [19]:
def load_image(path):
image = cv2.imread(path)
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
return image
In [20]:
from tqdm import tqdm
embeddings = []
embeddings = np.zeros((metadata.shape[0], 2622))
for i, meta in tqdm(enumerate(metadata)):
try:
image = load_image(str(meta))
image = (image/255.).astype(np.float32)
image = cv2.resize(image, (224, 224))
embeddings[i] = vgg_face_descriptor.predict(np.expand_dims(image, axis = 0))[0]
except:
embeddings[i] = np.zeros(2622)
Function for finding the distance between a pair of images¶
In [21]:
def distance(emb1, emb2):
return np.sum(np.square(emb1 - emb2))
Function to display the image pairs with distances between them¶
In [22]:
def show_pair(idx1, idx2):
plt.figure(figsize = (8, 3))
plt.suptitle(f'Distance = {distance(embeddings[idx1], embeddings[idx2]):.2f}')
plt.subplot(121)
plt.imshow(load_image(metadata[idx1].image_path()))
plt.subplot(122)
plt.imshow(load_image(metadata[idx2].image_path()))
Displaying the distances between pair for few samples¶
In [23]:
show_pair(170, 8)
show_pair(170, 167)
In [24]:
show_pair(1, 5)
show_pair(1, 180)
In [25]:
show_pair(200, 197)
show_pair(62, 197)
Splitting the data into train and test¶
In [26]:
train_idx = np.arange(metadata.shape[0]) % 9 != 0
test_idx = np.arange(metadata.shape[0]) % 9 == 0
# Features
X_train = np.array(embeddings)[train_idx]
X_test = np.array(embeddings)[test_idx]
# Labels
y_train = np.array([meta.name for meta in metadata[train_idx]])
y_test = np.array([meta.name for meta in metadata[test_idx]])
display(X_train.shape, X_test.shape, y_train.shape, y_test.shape)
Label Encoder¶
In [27]:
# Encode labels
en = LabelEncoder()
y_train = en.fit_transform(y_train)
y_test = en.fit_transform(y_test)
Standardizing the vectors¶
In [28]:
# Standarize features
sc = StandardScaler()
X_train_sc = sc.fit_transform(X_train)
X_test_sc = sc.fit_transform(X_test)
PCA - To reduce the dimension¶
In [29]:
# Covariance matrix
cov_matrix = np.cov(X_train_sc.T)
# Eigen values and vector
eig_vals, eig_vecs = np.linalg.eig(cov_matrix)
# Cumulative variance explained
tot = sum(eig_vals)
var_exp = [(i /tot) * 100 for i in sorted(eig_vals, reverse = True)]
cum_var_exp = np.cumsum(var_exp)
print('Cumulative Variance Explained', cum_var_exp)
In [30]:
# Setting the threshold and finding the index whose value is greater than the set threshold
thres = 95
res = list(filter(lambda i: i > thres, cum_var_exp))[0]
index = (cum_var_exp.tolist().index(res))
print(f'Index of element just greater than {thres}: {str(index)}')
Plotting the Variance explained vs Number of Dimensions¶
In [31]:
# Ploting
plt.figure(figsize = (15 , 7.2))
plt.bar(range(1, eig_vals.size + 1), var_exp, alpha = 0.5, align = 'center', label = 'Individual explained variance')
plt.step(range(1, eig_vals.size + 1), cum_var_exp, where = 'mid', label = 'Cumulative explained variance')
plt.axhline(y = thres, color = 'r', linestyle = '--')
plt.axvline(x = index, color = 'r', linestyle = '--')
plt.ylabel('Variance Explained %')
plt.xlabel('Number of Dimensions')
plt.legend(loc = 'BEST')
plt.tight_layout()
plt.show()
In [32]:
# Setting a random state
random_state = 32
In [33]:
# Reducing the dimensions
pca = PCA(n_components = index, random_state = random_state, svd_solver = 'full', whiten = True)
pca.fit(X_train_sc)
X_train_pca = pca.transform(X_train_sc)
X_test_pca = pca.transform(X_test_sc)
display(X_train_pca.shape, X_test_pca.shape)
In [34]:
svc_pca = SVC(C = 1, gamma = 0.001, kernel = 'rbf', class_weight = 'balanced', random_state = random_state)
svc_pca.fit(X_train_pca, y_train)
print('The accuracy of SVC for the train set is: {0:.3f}'.format(svc_pca.score(X_train_pca, y_train)*100))
In [35]:
# Predict
y_pred = svc_pca.predict(X_test_pca)
# Accuracy Score
print('The accuracy of SVC for the test set is: {}'.format(accuracy_score(y_test, y_pred).round(3)*100))
In [36]:
names = [name.split('_')[1].title().strip() for name in labels]
# Classification Report
print('Classification Report: \n{}'.format(classification_report(y_test, y_pred, target_names = np.unique(names))))
---------------------------------------------------------------------------------------------------------¶
PART - FOUR¶
Create an automation using computer vision to impute dynamic bounding boxes to locate cars or vehicles on the road¶
Importing the necessary libraries¶
In [ ]:
import os
import re
import cv2 # opencv library
import numpy as np
from os.path import isfile, join
import matplotlib.pyplot as plt
In [1]:
# Passing in the path along with the name of the mp4 file used
cap = cv2.VideoCapture("C:/Users/admin/Downloads/Video/video1.mp4")
# Capturing the number of frames in the video
length = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
# Printing the number of frames
print('The frame count is: ',length)
In [ ]:
import pixellib
from pixellib.instance import instance_segmentation
import cv2
# An rcnn model was downloaded and used for sematic segmentation here
segment_video = instance_segmentation()
segment_video.load_model("C:/Users/admin/Downloads/mask_rcnn_coco.h5")
segment_video.process_video("C:/Users/admin/Downloads/Video/video1.mp4", show_bboxes = True, frames_per_second= 15, output_video_name="traffic_monitor.mp4")
Screenshot of the output video¶
